Управление на сесиите в Python SQLAlchemy: Овладяване на обработката на транзакции за цялост на данните

SQLAlchemy е мощна и гъвкава библиотека за Python, която предоставя изчерпателен набор от инструменти за взаимодействие с бази данни. В основата на SQLAlchemy лежи концепцията за сесията, която действа като междинна зона за всички операции, които извършвате върху вашата база данни. Правилното управление на сесиите и транзакциите е от решаващо значение за поддържане на цялостта на данните и осигуряване на последователно поведение на базата данни, особено в сложни приложения, обработващи едновременни заявки.

Разбиране на сесиите в SQLAlchemy

Една сесия в SQLAlchemy представлява единица работа, разговор с базата данни. Тя проследява промените, направени в обекти, което ви позволява да ги запазвате в базата данни като единична атомарна операция. Мислете за нея като за работно пространство, където правите промени в данните, преди официално да ги запишете. Без добре управлявана сесия рискувате несъответствия в данните и потенциална повреда.

Създаване на сесия

Преди да можете да започнете да взаимодействате с вашата база данни, трябва да създадете сесия. Това включва първо установяване на връзка с базата данни с помощта на енджина на SQLAlchemy.

            from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

# Database connection string
db_url = 'sqlite:///:memory:'  # Replace with your database URL (e.g., PostgreSQL, MySQL)

# Create an engine
engine = create_engine(db_url, echo=False) # echo=True to see the generated SQL

# Define a base for declarative models
Base = declarative_base()

# Define a simple model
class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    email = Column(String)

    def __repr__(self):
        return f"<User(name='{self.name}', email='{self.email}')>"

# Create the table in the database
Base.metadata.create_all(engine)

# Create a session class
Session = sessionmaker(bind=engine)

# Instantiate a session
session = Session()

            

              
                Copy
              
            
          

В този пример:

• Импортираме необходимите модули на SQLAlchemy.
• Дефинираме низ за връзка с база данни (`db_url`). Този пример използва SQLite база данни в паметта за простота, но вие бихте го заменили с низ за връзка, подходящ за вашата система за бази данни (напр. PostgreSQL, MySQL). Специфичният формат варира в зависимост от енджина на базата данни и драйвера, който използвате. Консултирайте се с документацията на SQLAlchemy и документацията на вашия доставчик на база данни за правилния формат на низа за връзка.
• Създаваме `engine` с помощта на `create_engine()`. Енджинът е отговорен за управлението на пула от връзки и комуникацията с базата данни. Параметърът `echo=True` може да бъде полезен за отстраняване на грешки, тъй като ще отпечатва генерираните SQL изрази на конзолата.
• Дефинираме базов клас (`Base`) с помощта на `declarative_base()`. Това се използва като базов клас за всички наши модели на SQLAlchemy.
• Дефинираме `User` модел, картографирайки го към таблица в базата данни, наречена `users`.
• Създаваме таблицата в базата данни с помощта на `Base.metadata.create_all(engine)`.
• Създаваме клас за сесия с помощта на `sessionmaker(bind=engine)`. Това конфигурира класа за сесия да използва указания енджин.
• Накрая, инстанцираме сесия с помощта на `Session()`.

Разбиране на транзакциите

Транзакцията е поредица от операции с база данни, третирани като единична логическа единица работа. Транзакциите спазват ACID свойствата:

• Атомарност: Всички операции в транзакцията или успяват напълно, или се провалят напълно. Ако някоя част от транзакцията се провали, цялата транзакция се отменя.
• Последователност: Транзакцията трябва да поддържа базата данни във валидно състояние. Тя не може да нарушава никакви ограничения или правила на базата данни.
• Изолация: Едновременните транзакции са изолирани една от друга. Промените, направени от една транзакция, не са видими за други транзакции, докато първата транзакция не бъде записана.
• Устойчивост: След като една транзакция бъде записана, нейните промени са постоянни и ще оцелеят дори при сривове на системата.

SQLAlchemy предоставя механизми за управление на транзакции, осигурявайки поддържането на тези ACID свойства.

Основна обработка на транзакции

Най-честите транзакционни операции са запис и отмяна.

Записване на транзакции

Когато всички операции в рамките на една транзакция са успешно завършени, вие записвате транзакцията. Това запазва промените в базата данни.

            try:
    # Add a new user
    new_user = User(name='Alice Smith', email='alice.smith@example.com')
    session.add(new_user)

    # Commit the transaction
    session.commit()
    print("Transaction committed successfully!")

except Exception as e:
    # Handle exceptions
    print(f"An error occurred: {e}")
    session.rollback()
    print("Transaction rolled back.")

finally:
    session.close()

            

              
                Copy
              
            
          

В този пример:

• Добавяме нов `User` обект към сесията.
• Извикваме `session.commit()`, за да запазим промените в базата данни.
• Обвиваме кода в `try...except...finally` блок, за да обработим потенциални изключения.
• Ако възникне изключение, извикваме `session.rollback()`, за да отменим всички промени, направени по време на транзакцията.
• Винаги извикваме `session.close()` в `finally` блока, за да освободим сесията и да върнем връзката към пула от връзки. Това е от решаващо значение за избягване на изтичане на ресурси. Пропускането на затваряне на сесии може да доведе до изчерпване на връзките и нестабилност на приложението.

Отмяна на транзакции

Ако възникне грешка по време на транзакция или ако решите, че промените не трябва да бъдат запазвани, вие отменяте транзакцията. Това връща базата данни в състоянието й преди началото на транзакцията.

            try:
    # Add a user with an invalid email (example to force a rollback)
    invalid_user = User(name='Bob Johnson', email='invalid-email')
    session.add(invalid_user)

    # The commit will fail if the email is not validated on the database level
    session.commit()
    print("Transaction committed.")

except Exception as e:
    print(f"An error occurred: {e}")
    session.rollback()
    print("Transaction rolled back successfully.")

finally:
    session.close()

            

              
                Copy
              
            
          

В този пример, ако добавянето на `invalid_user` предизвика изключение (напр. поради нарушение на ограничение в базата данни), извикването на `session.rollback()` ще отмени опита за вмъкване, оставяйки базата данни непроменена.

Разширено управление на транзакции

Използване на `with` оператор за обхват на транзакциите

По-Pythonic и стабилен начин за управление на транзакции е използването на оператора `with`. Това гарантира, че сесията е правилно затворена, дори ако възникнат изключения.

            from contextlib import contextmanager

@contextmanager
def session_scope():
    """Provide a transactional scope around a series of operations."""
    session = Session()
    try:
        yield session
        session.commit()
    except Exception:
        session.rollback()
        raise
    finally:
        session.close()

# Usage:
with session_scope() as session:
    new_user = User(name='Charlie Brown', email='charlie.brown@example.com')
    session.add(new_user)
    # Operations within the 'with' block
    # If no exceptions occur, the transaction is committed automatically.
    # If an exception occurs, the transaction is rolled back automatically.
    print("User added.")

print("Transaction completed (committed or rolled back).")

            

              
                Copy
              
            
          

Функцията `session_scope` е мениджър на контекст. Когато влезете в `with` блока, се създава нова сесия. Когато излезете от `with` блока, сесията или се записва (ако не са възникнали изключения), или се отменя (ако е възникнало изключение). Сесията винаги се затваря във `finally` блока.

Вложени транзакции (точки за съхранение)

SQLAlchemy поддържа вложени транзакции с помощта на точки за съхранение (savepoints). Точката за съхранение ви позволява да отмените до определена точка в рамките на по-голяма транзакция, без да засягате цялата транзакция.

            try:
    with session_scope() as session:
        user1 = User(name='David Lee', email='david.lee@example.com')
        session.add(user1)
        session.flush()  # Send changes to the database but don't commit yet

        # Create a savepoint
        savepoint = session.begin_nested()

        try:
            user2 = User(name='Eve Wilson', email='eve.wilson@example.com')
            session.add(user2)
            session.flush()

            # Simulate an error
            raise ValueError("Simulated error during nested transaction")

        except Exception as e:
            print(f"Nested transaction error: {e}")
            savepoint.rollback()
            print("Nested transaction rolled back to savepoint.")

        # Continue with the outer transaction, user1 will still be added
        user3 = User(name='Frank Miller', email='frank.miller@example.com')
        session.add(user3)

except Exception as e:
    print(f"Outer transaction error: {e}")


#Commit will commit user1 and user3, but not user2 due to the nested rollback

try:
    with session_scope() as session:
        #Verify only user1 and user3 exist
        users = session.query(User).all()
        for user in users:
            print(user)
except Exception as e:
    print(f"Unexpected Exception: {e}") #Should not happen

            

              
                Copy
              
            
          

В този пример:

• Стартираме външна транзакция с помощта на `session_scope()`.
• Добавяме `user1` към сесията и изпращаме промените към базата данни. `flush()` изпраща промените към сървъра на базата данни, но *не ги записва*. Тя ви позволява да видите дали промените са валидни (напр. без нарушения на ограничения) преди да запишете цялата транзакция.
• Създаваме точка за съхранение с помощта на `session.begin_nested()`.
• В рамките на вложената транзакция добавяме `user2` и симулираме грешка.
• Отменяме вложената транзакция до точката за съхранение с помощта на `savepoint.rollback()`. Това отменя само промените, направени в рамките на вложената транзакция (т.е. добавянето на `user2`).
• Продължаваме с външната транзакция и добавяме `user3`.
• Външната транзакция се записва, запазвайки `user1` и `user3` в базата данни, докато `user2` се отхвърля поради отмяната до точката за съхранение.

Контролиране на нивата на изолация

Нивата на изолация определят степента, до която едновременните транзакции са изолирани една от друга. По-високите нива на изолация осигуряват по-голяма съгласуваност на данните, но могат да намалят паралелността и производителността. SQLAlchemy ви позволява да контролирате нивото на изолация на вашите транзакции.

Често срещаните нива на изолация включват:

• Нефиксирано четене (Read Uncommitted): Най-ниското ниво на изолация. Транзакциите могат да виждат нефиксирани промени, направени от други транзакции. Това може да доведе до мръсни четения (dirty reads).
• Фиксирано четене (Read Committed): Транзакциите могат да виждат само фиксирани промени, направени от други транзакции. Това предотвратява мръсните четения, но може да доведе до неповтарящи се четения (non-repeatable reads) и фантомни четения (phantom reads).
• Повтарящо се четене (Repeatable Read): Транзакциите могат да виждат същите данни през цялата транзакция, дори ако други транзакции ги променят. Това предотвратява мръсни четения и неповтарящи се четения, но може да доведе до фантомни четения.
• Сериализируемо (Serializable): Най-високото ниво на изолация. Транзакциите са напълно изолирани една от друга. Това предотвратява мръсни четения, неповтарящи се четения и фантомни четения, но може значително да намали паралелността.

Нивото на изолация по подразбиране зависи от системата на базата данни. Можете да зададете нивото на изолация при създаване на енджина или при започване на транзакция.

Пример (PostgreSQL):

            from sqlalchemy.dialects.postgresql import dialect

# Set isolation level when creating the engine
engine = create_engine('postgresql://user:password@host:port/database',
                       connect_args={'options': '-c statement_timeout=1000'} #Example of timeout
                      )

# Set the isolation level when beginning a transaction (database specific)
# For postgresql, it's recommended to set it on the connection, not engine.

from sqlalchemy import event
from sqlalchemy.pool import Pool

@event.listens_for(Pool, "connect")
def set_isolation_level(dbapi_connection, connection_record):
    existing_autocommit = dbapi_connection.autocommit
    dbapi_connection.autocommit = True
    cursor = dbapi_connection.cursor()
    cursor.execute("SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL SERIALIZABLE")
    dbapi_connection.autocommit = existing_autocommit
    cursor.close()


# Then transactions created via SQLAlchemy will use the configured isolation level.

            

              
                Copy
              
            
          

Важно: Методът за задаване на нива на изолация е специфичен за базата данни. Вижте документацията на вашата база данни за правилния синтаксис. Неправилното задаване на нива на изолация може да доведе до неочаквано поведение или грешки.

Обработка на паралелността

Когато множество потребители или процеси имат достъп до едни и същи данни едновременно, е от решаващо значение да се обработва паралелността правилно, за да се предотврати повреда на данните и да се осигури съгласуваност на данните. SQLAlchemy предоставя няколко механизма за обработка на паралелността, включително оптимистично заключване и песимистично заключване.

Оптимистично заключване

Оптимистичното заключване предполага, че конфликтите са редки. То проверява за промени, направени от други транзакции, преди да запише транзакция. Ако бъде открит конфликт, транзакцията се отменя.

За да реализирате оптимистично заключване, обикновено добавяте колона за версия към вашата таблица. Тази колона автоматично се увеличава всеки път, когато редът се актуализира.

            from sqlalchemy import Column, Integer, String, Integer
from sqlalchemy.orm import declarative_base

Base = declarative_base()

class Article(Base):
    __tablename__ = 'articles'
    id = Column(Integer, primary_key=True)
    title = Column(String)
    content = Column(String)
    version = Column(Integer, nullable=False, default=1)

    def __repr__(self):
        return f"<Article(title='{self.title}', version='{self.version}')>"

#Inside of the try catch block

def update_article(session, article_id, new_content):
    article = session.query(Article).filter_by(id=article_id).first()

    if article is None:
        raise ValueError("Article not found")

    original_version = article.version

    # Update the content and increment the version
    article.content = new_content
    article.version += 1

    # Attempt to update, checking the version column in the WHERE clause
    rows_affected = session.query(Article).filter(
        Article.id == article_id,
        Article.version == original_version
    ).update({
        Article.content: new_content,
        Article.version: article.version
    }, synchronize_session=False)

    if rows_affected == 0:
        session.rollback()
        raise ValueError("Conflict: Article has been updated by another transaction.")
    
    session.commit()

            

              
                Copy
              
            
          

В този пример:

• Добавяме колона `version` към модела `Article`.
• Преди да актуализираме статията, съхраняваме текущия номер на версията.
• В израза `UPDATE` включваме клауза `WHERE`, която проверява дали колоната за версия все още е равна на съхранения номер на версията. `synchronize_session=False` предотвратява повторното зареждане на актуализирания обект от SQLAlchemy; ние изрично обработваме версиите.
• Ако колоната за версия е била променена от друга транзакция, изразът `UPDATE` няма да засегне нито един ред (rows_affected ще бъде 0) и ние предизвикваме изключение.
• Отменяме транзакцията и уведомяваме потребителя, че е възникнал конфликт.

Песимистично заключване

Песимистичното заключване предполага, че конфликтите са вероятни. То придобива заключване върху ред или таблица, преди да ги промени. Това предотвратява променянето на данните от други транзакции, докато заключването не бъде освободено.

SQLAlchemy предоставя няколко функции за придобиване на заключвания, като `with_for_update()`.

            # Example using PostgreSQL
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker, declarative_base

# Database setup (replace with your actual database URL)
db_url = 'postgresql://user:password@host:port/database'
engine = create_engine(db_url, echo=False) #Set echo to true if you would like to see the SQL generated
Base = declarative_base()

class Item(Base):
    __tablename__ = 'items'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    value = Column(Integer)

    def __repr__(self):
        return f"<Item(name='{self.name}', value='{self.value}')>"

Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)

#Function to update the item (within a try/except)
def update_item_value(session, item_id, new_value):
    # Acquire a pessimistic lock on the item
    item = session.query(Item).filter(Item.id == item_id).with_for_update().first()

    if item is None:
        raise ValueError("Item not found")

    # Update the item's value
    item.value = new_value
    session.commit()
    return True

            

              
                Copy
              
            
          

В този пример:

• Използваме `with_for_update()`, за да придобием заключване върху реда `Item`, преди да го актуализираме. Това предотвратява други транзакции да променят реда, докато текущата транзакция не бъде записана или отменена. Функцията `with_for_update()` е специфична за базата данни; консултирайте се с документацията на вашата база данни за подробности. Някои бази данни може да имат различни механизми за заключване или синтаксис.

Важно: Песимистичното заключване може да намали паралелността и производителността, така че го използвайте само когато е необходимо.

Най-добри практики за обработка на изключения

Правилното обработване на изключения е от решаващо значение за осигуряване на цялостта на данните и предотвратяване на сривове на приложенията. Винаги обвивайте операциите си с база данни в блокове `try...except` и обработвайте изключенията по подходящ начин.

Ето няколко най-добри практики за обработка на изключения:

• Прихващане на специфични изключения: Избягвайте прихващането на общи изключения като `Exception`. Прихващайте специфични изключения като `sqlalchemy.exc.IntegrityError` или `sqlalchemy.exc.OperationalError`, за да обработвате различни видове грешки по различен начин.
• Отмяна на транзакции: Винаги отменяйте транзакцията, ако възникне изключение.
• Записване на изключения: Записвайте изключения, за да помогнете за диагностициране и отстраняване на проблеми. Включете възможно най-много контекст в дневниците си (напр. ID на потребителя, входните данни, времевият печат).
• Повторно предизвикване на изключения, когато е подходящо: Ако не можете да обработите изключение, повторно го предизвикайте, за да позволите на по-висок ниво обработчик да се справи с него.
• Почистване на ресурси: Винаги затваряйте сесията и освобождавайте всички други ресурси в `finally` блок.

            import logging
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker, declarative_base
from sqlalchemy.exc import IntegrityError, OperationalError

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# Database setup (replace with your actual database URL)
db_url = 'postgresql://user:password@host:port/database'
engine = create_engine(db_url, echo=False)
Base = declarative_base()

class Product(Base):
    __tablename__ = 'products'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    price = Column(Integer)

    def __repr__(self):
        return f"<Product(name='{self.name}', price='{self.price}')>"

Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)

# Function to add a product
def add_product(session, name, price):
    try:
        new_product = Product(name=name, price=price)
        session.add(new_product)
        session.commit()
        logging.info(f"Product '{name}' added successfully.")
        return True
    except IntegrityError as e:
        session.rollback()
        logging.error(f"IntegrityError: {e}")
        #Handle database constraint violations (e.g., duplicate name)
        return False
    except OperationalError as e:
        session.rollback()
        logging.error(f"OperationalError: {e}")
        #Handle connection errors or other operational issues
        return False
    except Exception as e:
        session.rollback()
        logging.exception(f"An unexpected error occurred: {e}")
        # Handle any other unexpected errors
        return False
    finally:
        session.close()

            

              
                Copy
              
            
          

В този пример:

• Конфигурираме регистрирането (logging), за да записваме събития по време на процеса.
• Прихващаме специфични изключения като `IntegrityError` (за нарушения на ограничения) и `OperationalError` (за грешки във връзката).
• Отменяме транзакцията в блоковете `except`.
• Записваме изключенията с помощта на модула `logging`. Методът `logging.exception()` автоматично включва проследяването на стека в съобщението за дневник.
• Повторно предизвикваме изключението, ако не можем да го обработим.
• Затваряме сесията във `finally` блока.

Пул от връзки с база данни

SQLAlchemy използва пул от връзки (connection pooling) за ефективно управление на връзките с база данни. Пулът от връзки поддържа набор от отворени връзки към базата данни, позволявайки на приложенията да преизползват съществуващи връзки, вместо да създават нови за всяка заявка. Това може значително да подобри производителността, особено в приложения, които обработват голям брой едновременни заявки.

Функцията `create_engine()` на SQLAlchemy автоматично създава пул от връзки. Можете да конфигурирате пула от връзки, като подадете аргументи на `create_engine()`.

Често срещаните параметри на пула от връзки включват:

• pool_size: Максималният брой връзки в пула.
• max_overflow: Броят на връзките, които могат да бъдат създадени над `pool_size`.
• pool_recycle: Броят секунди, след които връзката се рециклира.
• pool_timeout: Броят секунди за изчакване на връзка, за да стане достъпна.

            engine = create_engine('postgresql://user:password@host:port/database',
                       pool_size=5, #Maximum pool size
                       max_overflow=10, #Maximum overflow
                       pool_recycle=3600, #Recycle connections after 1 hour
                       pool_timeout=30
                      )

            

              
                Copy
              
            
          

Важно: Изберете подходящи настройки на пула от връзки въз основа на нуждите на вашето приложение и възможностите на сървъра на базата данни. Неправилно конфигуриран пул от връзки може да доведе до проблеми с производителността или изчерпване на връзките.

Асинхронни транзакции (Async SQLAlchemy)

За съвременни приложения, изискващи висока паралелност, особено тези, изградени с асинхронни рамки като FastAPI или AsyncIO, SQLAlchemy предлага асинхронна версия, наречена Async SQLAlchemy.

Async SQLAlchemy предоставя асинхронни версии на основните компоненти на SQLAlchemy, което ви позволява да извършвате операции с база данни, без да блокирате цикъла на събитията. Това може значително да подобри производителността и мащабируемостта на вашите приложения.

Ето един основен пример за използване на Async SQLAlchemy:

            from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import declarative_base
from sqlalchemy import Column, Integer, String
import asyncio

# Database setup (replace with your actual database URL)
db_url = 'postgresql+asyncpg://user:password@host:port/database'
engine = create_async_engine(db_url, echo=False)
Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    email = Column(String)

    def __repr__(self):
        return f"<User(name='{self.name}', email='{self.email}')>"

async def create_db_and_tables():
    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)


async def add_user(name, email):
    async with AsyncSession(engine) as session:
        new_user = User(name=name, email=email)
        session.add(new_user)
        await session.commit()

async def main():
    await create_db_and_tables()
    await add_user("Async User", "async.user@example.com")

if __name__ == "__main__":
    asyncio.run(main())

            

              
                Copy
              
            
          

Основни разлики от синхронния SQLAlchemy:

• Използва се `create_async_engine` вместо `create_engine`.
• Използва се `AsyncSession` вместо `Session`.
• Всички операции с база данни са асинхронни и трябва да бъдат изчакани с `await`.
• Трябва да се използват асинхронни драйвери за база данни (напр. `asyncpg` за PostgreSQL).

Важно: Async SQLAlchemy изисква драйвер за база данни, който поддържа асинхронни операции. Уверете се, че имате инсталиран и конфигуриран правилния драйвер.

Заключение

Овладяването на управлението на сесиите и транзакциите в SQLAlchemy е от съществено значение за изграждането на стабилни и надеждни Python приложения, които взаимодействат с бази данни. Чрез разбиране на концепциите за сесии, транзакции, нива на изолация и паралелност, както и чрез спазване на най-добрите практики за обработка на изключения и пул от връзки, можете да осигурите цялост на данните и да оптимизирате производителността на вашите приложения.

Независимо дали изграждате малко уеб приложение или голяма корпоративна система, SQLAlchemy предоставя инструментите, от които се нуждаете, за да управлявате ефективно взаимодействията си с база данни. Не забравяйте винаги да приоритизирате цялостта на данните и да обработвате потенциалните грешки елегантно, за да осигурите надеждността на вашите приложения.

Помислете за проучване на разширени теми като:

• Двуфазов commit (2PC): За транзакции, обхващащи множество бази данни.
• Sharding: За разпределяне на данни между множество сървъри на база данни.
• Миграции на база данни: Използване на инструменти като Alembic за управление на промените в схемата на база данни.